Research
Security News
Quasar RAT Disguised as an npm Package for Detecting Vulnerabilities in Ethereum Smart Contracts
Socket researchers uncover a malicious npm package posing as a tool for detecting vulnerabilities in Etherium smart contracts.
unist-util-visit-parents
Advanced tools
unist utility to recursively walk over nodes, with ancestral information
The unist-util-visit-parents package is a utility for traversing Unist syntax trees. It allows for visiting nodes, optionally filtered by type, and provides access to parent nodes during traversal. This can be particularly useful for manipulating or inspecting the structure of documents parsed into Unist syntax trees, such as Markdown or HTML parsed by remark or rehype processors.
Visiting nodes with access to their parents
This feature allows you to visit all nodes of a specified type ('paragraph' in this example) in a Unist syntax tree, and for each node, you have access to an array of its ancestor nodes. This is useful for context-aware processing or transformations.
visit(tree, 'paragraph', (node, ancestors) => {
console.log(node);
console.log(ancestors);
});
Visiting all nodes without filtering
This feature enables visiting all nodes in the syntax tree without filtering by type. Each visited node is accompanied by its ancestors, allowing for comprehensive traversal and manipulation of the tree.
visit(tree, (node, ancestors) => {
console.log(node);
console.log(ancestors);
});
Similar to unist-util-visit-parents, unist-util-visit allows for traversing Unist trees and applying a function to each visited node. The key difference is that unist-util-visit does not provide access to the ancestors of each node, focusing instead on simpler visitation needs.
This package provides a way to select nodes in a Unist tree using CSS-like selectors. While it serves a different primary purpose from unist-util-visit-parents, it offers an alternative approach to node selection and manipulation in Unist trees.
unist utility to visit nodes, with ancestral information.
npm:
npm install unist-util-visit-parents
var remark = require('remark')
var visit = require('unist-util-visit-parents')
var tree = remark.parse('Some _emphasis_, **importance**, and `code`.')
visit(tree, 'strong', visitor)
function visitor(node, ancestors) {
console.log(ancestors)
}
Yields:
[ { type: 'root', children: [ [Object] ] },
{ type: 'paragraph',
children:
[ [Object],
[Object],
[Object],
[Object],
[Object],
[Object],
[Object] ] } ]
visit(tree[, test], visitor[, reverse])
Visit nodes (inclusive descendants of tree
), with
ancestral information.
Optionally filtering nodes.
Optionally in reverse.
This algorithm performs depth-first
tree traversal in preorder (NLR), or
if reverse
is given, in reverse preorder (NRL).
Walking the tree is an intensive task.
Make use of the return values of the visitor when possible.
Instead of walking a tree multiple times with different test
s, walk it once
without a test, and use unist-util-is
to check if a node matches a test,
and then perform different operations.
tree
(Node
) — Tree to traversetest
(Test
, optional) — is
-compatible test (such as a
type)visitor
(Function) — Function invoked when a node is found
that passes test
reverse
(boolean
, default: false
) — The tree is traversed in
preorder (NLR), visiting the node itself, then its head, etc.
When reverse
is passed, the tree is traversed in reverse preorder (NRL):
the node itself is visited, then its tail, etc.next? = visitor(node, ancestors)
Invoked when a node (matching test
, if given) is found.
Visitors are free to transform node
.
They can also transform the parent of node (the last of ancestors
).
Replacing node
itself, if visit.SKIP
is not returned, still causes its
descendants to be visited.
If adding or removing previous siblings (or next siblings, in case of
reverse
) of node
, visitor
should return a new index
(number
)
to specify the sibling to traverse after node
is traversed.
Adding or removing next siblings of node
(or previous siblings, in case of
reverse) is handled as expected without needing to return a new index
.
Removing the children
property of an ancestor still results in them being
traversed.
The return value can have the following forms:
index
(number
) — Treated as a tuple of [CONTINUE, index]
action
(*
) — Treated as a tuple of [action]
tuple
(Array.<*>
) — List with one or two values, the first an action
,
the second and index
.
Note that passing a tuple only makes sense if the action
is SKIP
.
If the action
is EXIT
, that action can be returned.
If the action
is CONTINUE
, index
can be returned.action
An action can have the following values:
visit.EXIT
(false
) — Stop traversing immediatelyvisit.CONTINUE
(true
) — Continue traversing as normal (same behaviour
as not returning anything)visit.SKIP
('skip'
) — Do not traverse this node’s children; continue
with the specified indexindex
index
(number
) — Move to the sibling at index
next (after node
itself is completely traversed).
Useful if mutating the tree, such as removing the node the visitor is currently
on, or any of its previous siblings (or next siblings, in case of reverse
)
Results less than 0
or greater than or equal to children.length
stop
traversing the parent
unist-util-visit
— Like visit-parents
, but with one parentunist-util-filter
— Create a new tree with all nodes that pass a testunist-util-map
— Create a new tree with all nodes mapped by a given functionunist-util-flatmap
— Create a new tree by mapping (to an array) with the given functionunist-util-remove
— Remove nodes from a tree that pass a testunist-util-select
— Select nodes with CSS-like selectorsSee contributing.md
in syntax-tree/.github
for ways to get
started.
See support.md
for ways to get help.
This project has a code of conduct. By interacting with this repository, organization, or community you agree to abide by its terms.
FAQs
unist utility to recursively walk over nodes, with ancestral information
The npm package unist-util-visit-parents receives a total of 14,591,307 weekly downloads. As such, unist-util-visit-parents popularity was classified as popular.
We found that unist-util-visit-parents demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 2 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Research
Security News
Socket researchers uncover a malicious npm package posing as a tool for detecting vulnerabilities in Etherium smart contracts.
Security News
Research
A supply chain attack on Rspack's npm packages injected cryptomining malware, potentially impacting thousands of developers.
Research
Security News
Socket researchers discovered a malware campaign on npm delivering the Skuld infostealer via typosquatted packages, exposing sensitive data.